diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 3283b1a..f86e1f5 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Change Log</title>
@@ -136,6 +136,7 @@
     <li>Documentation Changes
 		<ul>
 			<li>Added titles to all user manual pages.</li>
+			<li>Added attributes into &lt;html&gt; of userguide for valid html.</li>
 			<li>Added <a href="http://codeigniter.com/user_guide/libraries/zip.html">Zip Encoding Class</a> to the table of contents of the userguide.</li>
 			<li>Moved part of the userguide menu javascript to an external file.</li>
 			<li>Documented <kbd>distinct()</kbd> in <a href="./database/active_record.html">Active Record</a>. </li>
@@ -308,7 +309,7 @@
 <li>Added new helper:  <a href="./helpers/smiley_helper.html">Smiley Helper</a></li>
 <li>Added support for &lt;ul> and &lt;ol> lists in the  <a href="./helpers/html_helper.html">HTML Helper</a></li>
 <li>Added the ability to rewrite <a href="./general/alternative_php.html">short tags</a> on-the-fly, converting them to standard PHP statements, for those servers that do not support short tags.  This allows the cleaner syntax to be used regardless of whether it's supported by the server.</li>
-<li>Added the ability to <a href="./general/managing_apps.html">rename or relocate the "application" folder</a>.
+<li>Added the ability to <a href="./general/managing_apps.html">rename or relocate the "application" folder</a>.</li>
 <li>Added more thorough initialization in the upload class so that all class variables are reset.</li>
 <li>Added "is_numeric" to validation, which uses the native PHP is_numeric function.</li>
 <li>Improved the URI handler to make it more reliable when the $config['uri_protocol'] item is set to AUTO.</li>
@@ -492,7 +493,7 @@
 <li>Added support for running standard <a href="urls.html">query string URLs</a>.  These can be optionally enabled in your config file.</li>
 <li>Added the ability to  <a href="urls.html">specify a "suffix"</a>, which will be appended to your URLs.  For example, you could add .html to your URLs, making them appear static. This feature is enabled in your config file.</li>
 <li>Added a new error template for use with native PHP errors.</li>
-<li>Added "alternator" function in the <a href="./helpers/string_helper.html">string helpers</a>.
+<li>Added "alternator" function in the <a href="./helpers/string_helper.html">string helpers</a>.</li>
 <li>Removed slashing from the input class. After much debate we decided to kill this feature.</li>
 <li>Change the commenting style in the scripts to the PEAR standard so that IDEs and tools like phpDocumenter can harvest the comments.</li>
 <li>Added better class and function name-spacing to avoid collisions with user developed classes. All CodeIgniter classes are now prefixed with <dfn>CI_</dfn> and
diff --git a/user_guide/database/active_record.html b/user_guide/database/active_record.html
index 4ba5bfd..bf43699 100644
--- a/user_guide/database/active_record.html
+++ b/user_guide/database/active_record.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Active Record</title>
diff --git a/user_guide/database/caching.html b/user_guide/database/caching.html
index 9e007f9..d286c92 100644
--- a/user_guide/database/caching.html
+++ b/user_guide/database/caching.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Database Caching Class</title>
diff --git a/user_guide/database/call_function.html b/user_guide/database/call_function.html
index 87ff2df..97661de 100644
--- a/user_guide/database/call_function.html
+++ b/user_guide/database/call_function.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Custom Function Calls</title>
diff --git a/user_guide/database/configuration.html b/user_guide/database/configuration.html
index b6126d9..c9ad2e3 100644
--- a/user_guide/database/configuration.html
+++ b/user_guide/database/configuration.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Database Configuration</title>
diff --git a/user_guide/database/connecting.html b/user_guide/database/connecting.html
index adf0c51..a86866d 100644
--- a/user_guide/database/connecting.html
+++ b/user_guide/database/connecting.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Connecting to your Database</title>
diff --git a/user_guide/database/examples.html b/user_guide/database/examples.html
index 434aa82..d8c01aa 100644
--- a/user_guide/database/examples.html
+++ b/user_guide/database/examples.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Database Quick Start</title>
diff --git a/user_guide/database/fields.html b/user_guide/database/fields.html
index de5e021..6da71c1 100644
--- a/user_guide/database/fields.html
+++ b/user_guide/database/fields.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Field Data</title>
diff --git a/user_guide/database/forge.html b/user_guide/database/forge.html
index 0a40454..7fc6589 100644
--- a/user_guide/database/forge.html
+++ b/user_guide/database/forge.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Database Utility Class</title>
diff --git a/user_guide/database/helpers.html b/user_guide/database/helpers.html
index 6567c02..edf7fae 100644
--- a/user_guide/database/helpers.html
+++ b/user_guide/database/helpers.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Query Helper Functions</title>
diff --git a/user_guide/database/index.html b/user_guide/database/index.html
index 6ad90e9..76c32e2 100644
--- a/user_guide/database/index.html
+++ b/user_guide/database/index.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : The Database Class</title>
diff --git a/user_guide/database/queries.html b/user_guide/database/queries.html
index 21b550a..687076f 100644
--- a/user_guide/database/queries.html
+++ b/user_guide/database/queries.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Queries</title>
diff --git a/user_guide/database/results.html b/user_guide/database/results.html
index 6c6142c..6a7bf04 100644
--- a/user_guide/database/results.html
+++ b/user_guide/database/results.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Generating Query Results</title>
diff --git a/user_guide/database/table_data.html b/user_guide/database/table_data.html
index c5d2aaa..9f1c974 100644
--- a/user_guide/database/table_data.html
+++ b/user_guide/database/table_data.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Table Data</title>
diff --git a/user_guide/database/transactions.html b/user_guide/database/transactions.html
index 19f091e..1c2d9b1 100644
--- a/user_guide/database/transactions.html
+++ b/user_guide/database/transactions.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Transactions</title>
diff --git a/user_guide/database/utilities.html b/user_guide/database/utilities.html
index 56a728b..b6cdb8a 100644
--- a/user_guide/database/utilities.html
+++ b/user_guide/database/utilities.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Database Utility Class</title>
diff --git a/user_guide/general/alternative_php.html b/user_guide/general/alternative_php.html
index a91af15..3446b26 100644
--- a/user_guide/general/alternative_php.html
+++ b/user_guide/general/alternative_php.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Alternate PHP Syntax for View Files</title>
diff --git a/user_guide/general/ancillary_classes.html b/user_guide/general/ancillary_classes.html
index 148850e..daf5fb6 100644
--- a/user_guide/general/ancillary_classes.html
+++ b/user_guide/general/ancillary_classes.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Creating Ancillary Classes</title>
diff --git a/user_guide/general/autoloader.html b/user_guide/general/autoloader.html
index 8d000a9..8cf8919 100644
--- a/user_guide/general/autoloader.html
+++ b/user_guide/general/autoloader.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Auto-loading Resources</title>
diff --git a/user_guide/general/caching.html b/user_guide/general/caching.html
index 5cf8116..ecf0653 100644
--- a/user_guide/general/caching.html
+++ b/user_guide/general/caching.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Web Page Caching</title>
diff --git a/user_guide/general/controllers.html b/user_guide/general/controllers.html
index 3b25087..cd11eb1 100644
--- a/user_guide/general/controllers.html
+++ b/user_guide/general/controllers.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Controllers</title>
diff --git a/user_guide/general/core_classes.html b/user_guide/general/core_classes.html
index 9ba027c..c8117b9 100644
--- a/user_guide/general/core_classes.html
+++ b/user_guide/general/core_classes.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Creating Core System Classes</title>
diff --git a/user_guide/general/creating_libraries.html b/user_guide/general/creating_libraries.html
index 38ad107..370f1d4 100644
--- a/user_guide/general/creating_libraries.html
+++ b/user_guide/general/creating_libraries.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Creating Libraries</title>
diff --git a/user_guide/general/credits.html b/user_guide/general/credits.html
index eb1d4b8..04f9475 100644
--- a/user_guide/general/credits.html
+++ b/user_guide/general/credits.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Credits</title>
diff --git a/user_guide/general/errors.html b/user_guide/general/errors.html
index 4db0c4d..a3baf69 100644
--- a/user_guide/general/errors.html
+++ b/user_guide/general/errors.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Error Handling</title>
diff --git a/user_guide/general/helpers.html b/user_guide/general/helpers.html
index 65e549c..f4e607f 100644
--- a/user_guide/general/helpers.html
+++ b/user_guide/general/helpers.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Helper Functions</title>
diff --git a/user_guide/general/hooks.html b/user_guide/general/hooks.html
index 0441aca..63bf4be 100644
--- a/user_guide/general/hooks.html
+++ b/user_guide/general/hooks.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Hooks</title>
diff --git a/user_guide/general/index.html b/user_guide/general/index.html
index a220042..f7cb9e8 100644
--- a/user_guide/general/index.html
+++ b/user_guide/general/index.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Getting Started With CodeIgniter</title>
diff --git a/user_guide/general/libraries.html b/user_guide/general/libraries.html
index 3ae4c58..a9d3703 100644
--- a/user_guide/general/libraries.html
+++ b/user_guide/general/libraries.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Using CodeIgniter Libraries</title>
diff --git a/user_guide/general/managing_apps.html b/user_guide/general/managing_apps.html
index 3cc899e..7b0613b 100644
--- a/user_guide/general/managing_apps.html
+++ b/user_guide/general/managing_apps.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Managing your Applications</title>
diff --git a/user_guide/general/models.html b/user_guide/general/models.html
index 3164669..9a672ff 100644
--- a/user_guide/general/models.html
+++ b/user_guide/general/models.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Models</title>
diff --git a/user_guide/general/plugins.html b/user_guide/general/plugins.html
index a34f368..2027289 100644
--- a/user_guide/general/plugins.html
+++ b/user_guide/general/plugins.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Plugins</title>
diff --git a/user_guide/general/profiling.html b/user_guide/general/profiling.html
index f9c937d..adb1684 100644
--- a/user_guide/general/profiling.html
+++ b/user_guide/general/profiling.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Profiling Your Application</title>
diff --git a/user_guide/general/quick_reference.html b/user_guide/general/quick_reference.html
index 9dd9e9e..7ac2938 100644
--- a/user_guide/general/quick_reference.html
+++ b/user_guide/general/quick_reference.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Quick Reference Chart</title>
diff --git a/user_guide/general/requirements.html b/user_guide/general/requirements.html
index df63b91..9acbd57 100644
--- a/user_guide/general/requirements.html
+++ b/user_guide/general/requirements.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Server Requirements</title>
diff --git a/user_guide/general/routing.html b/user_guide/general/routing.html
index 9b29c3f..ce1700b 100644
--- a/user_guide/general/routing.html
+++ b/user_guide/general/routing.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : URI Routing</title>
diff --git a/user_guide/general/scaffolding.html b/user_guide/general/scaffolding.html
index 27ee209..cb4eceb 100644
--- a/user_guide/general/scaffolding.html
+++ b/user_guide/general/scaffolding.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Scaffolding</title>
diff --git a/user_guide/general/security.html b/user_guide/general/security.html
index 9a48c7e..0dd1f1f 100644
--- a/user_guide/general/security.html
+++ b/user_guide/general/security.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Security</title>
diff --git a/user_guide/general/urls.html b/user_guide/general/urls.html
index f3a01e5..a3389de 100644
--- a/user_guide/general/urls.html
+++ b/user_guide/general/urls.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : CodeIgniter URLs</title>
diff --git a/user_guide/general/views.html b/user_guide/general/views.html
index 5ad9fc5..e41503f 100644
--- a/user_guide/general/views.html
+++ b/user_guide/general/views.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Views</title>
diff --git a/user_guide/helpers/array_helper.html b/user_guide/helpers/array_helper.html
index a9c443c..b9fac01 100644
--- a/user_guide/helpers/array_helper.html
+++ b/user_guide/helpers/array_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Array Helper</title>
diff --git a/user_guide/helpers/cookie_helper.html b/user_guide/helpers/cookie_helper.html
index 37167d8..81e679b 100644
--- a/user_guide/helpers/cookie_helper.html
+++ b/user_guide/helpers/cookie_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Cookie Helper</title>
diff --git a/user_guide/helpers/date_helper.html b/user_guide/helpers/date_helper.html
index 73a980a..d98a72e 100644
--- a/user_guide/helpers/date_helper.html
+++ b/user_guide/helpers/date_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Date Helper</title>
diff --git a/user_guide/helpers/directory_helper.html b/user_guide/helpers/directory_helper.html
index fcb10cc..0fd8469 100644
--- a/user_guide/helpers/directory_helper.html
+++ b/user_guide/helpers/directory_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Directory Helper</title>
diff --git a/user_guide/helpers/download_helper.html b/user_guide/helpers/download_helper.html
index a82d198..7da5077 100644
--- a/user_guide/helpers/download_helper.html
+++ b/user_guide/helpers/download_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Download Helper</title>
diff --git a/user_guide/helpers/email_helper.html b/user_guide/helpers/email_helper.html
index fe0e3cc..b7aff6f 100644
--- a/user_guide/helpers/email_helper.html
+++ b/user_guide/helpers/email_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Download Helper</title>
diff --git a/user_guide/helpers/file_helper.html b/user_guide/helpers/file_helper.html
index d2d61ad..f78cc58 100644
--- a/user_guide/helpers/file_helper.html
+++ b/user_guide/helpers/file_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : File Helper</title>
diff --git a/user_guide/helpers/form_helper.html b/user_guide/helpers/form_helper.html
index cc2dda1..ed583b0 100644
--- a/user_guide/helpers/form_helper.html
+++ b/user_guide/helpers/form_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Form Helper</title>
diff --git a/user_guide/helpers/html_helper.html b/user_guide/helpers/html_helper.html
index c3133a1..be59bf0 100644
--- a/user_guide/helpers/html_helper.html
+++ b/user_guide/helpers/html_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : HTML Helper</title>
diff --git a/user_guide/helpers/index.html b/user_guide/helpers/index.html
index 23fb245..04aafe9 100644
--- a/user_guide/helpers/index.html
+++ b/user_guide/helpers/index.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Helper Functions</title>
diff --git a/user_guide/helpers/inflector_helper.html b/user_guide/helpers/inflector_helper.html
index 699be58..e931cb1 100644
--- a/user_guide/helpers/inflector_helper.html
+++ b/user_guide/helpers/inflector_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Inflector Helper</title>
diff --git a/user_guide/helpers/security_helper.html b/user_guide/helpers/security_helper.html
index 4cd5d6e..8b15d90 100644
--- a/user_guide/helpers/security_helper.html
+++ b/user_guide/helpers/security_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Security Helper</title>
diff --git a/user_guide/helpers/smiley_helper.html b/user_guide/helpers/smiley_helper.html
index 50b095f..5080548 100644
--- a/user_guide/helpers/smiley_helper.html
+++ b/user_guide/helpers/smiley_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Smiley Helper</title>
diff --git a/user_guide/helpers/string_helper.html b/user_guide/helpers/string_helper.html
index 206c5ea..4cebf50 100644
--- a/user_guide/helpers/string_helper.html
+++ b/user_guide/helpers/string_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : String Helper</title>
diff --git a/user_guide/helpers/text_helper.html b/user_guide/helpers/text_helper.html
index 43db044..5e6af00 100644
--- a/user_guide/helpers/text_helper.html
+++ b/user_guide/helpers/text_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Text Helper</title>
diff --git a/user_guide/helpers/typography_helper.html b/user_guide/helpers/typography_helper.html
index 5a28384..543db3f 100644
--- a/user_guide/helpers/typography_helper.html
+++ b/user_guide/helpers/typography_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Typography Helper</title>
diff --git a/user_guide/helpers/url_helper.html b/user_guide/helpers/url_helper.html
index d28b695..a177a1c 100644
--- a/user_guide/helpers/url_helper.html
+++ b/user_guide/helpers/url_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : URL Helper</title>
diff --git a/user_guide/helpers/xml_helper.html b/user_guide/helpers/xml_helper.html
index 936f1e8..086a3f2 100644
--- a/user_guide/helpers/xml_helper.html
+++ b/user_guide/helpers/xml_helper.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : XML Helper</title>
diff --git a/user_guide/index.html b/user_guide/index.html
index 62ebcbc..491e5c8 100644
--- a/user_guide/index.html
+++ b/user_guide/index.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Welcome to CodeIgniter</title>
diff --git a/user_guide/installation/downloads.html b/user_guide/installation/downloads.html
index 03ce391..f6561d4 100644
--- a/user_guide/installation/downloads.html
+++ b/user_guide/installation/downloads.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Downloading CodeIgniter</title>
diff --git a/user_guide/installation/index.html b/user_guide/installation/index.html
index 89bd256..f01fbb3 100644
--- a/user_guide/installation/index.html
+++ b/user_guide/installation/index.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Installation Instructions</title>
diff --git a/user_guide/installation/troubleshooting.html b/user_guide/installation/troubleshooting.html
index 8012261..294ec8a 100644
--- a/user_guide/installation/troubleshooting.html
+++ b/user_guide/installation/troubleshooting.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Troubleshooting</title>
diff --git a/user_guide/installation/upgrade_120.html b/user_guide/installation/upgrade_120.html
index 01ffa0a..554a80a 100644
--- a/user_guide/installation/upgrade_120.html
+++ b/user_guide/installation/upgrade_120.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrade_130.html b/user_guide/installation/upgrade_130.html
index 202cc33..95cec49 100644
--- a/user_guide/installation/upgrade_130.html
+++ b/user_guide/installation/upgrade_130.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrade_131.html b/user_guide/installation/upgrade_131.html
index 3219540..dad3e8c 100644
--- a/user_guide/installation/upgrade_131.html
+++ b/user_guide/installation/upgrade_131.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrade_132.html b/user_guide/installation/upgrade_132.html
index 2cf13cc..9a6d075 100644
--- a/user_guide/installation/upgrade_132.html
+++ b/user_guide/installation/upgrade_132.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrade_133.html b/user_guide/installation/upgrade_133.html
index 9bd50ac..b71694c 100644
--- a/user_guide/installation/upgrade_133.html
+++ b/user_guide/installation/upgrade_133.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrade_140.html b/user_guide/installation/upgrade_140.html
index 6ee915f..e03547b 100644
--- a/user_guide/installation/upgrade_140.html
+++ b/user_guide/installation/upgrade_140.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrade_141.html b/user_guide/installation/upgrade_141.html
index 90bb62a..239fa51 100644
--- a/user_guide/installation/upgrade_141.html
+++ b/user_guide/installation/upgrade_141.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrade_150.html b/user_guide/installation/upgrade_150.html
index a6c93e8..456e4da 100644
--- a/user_guide/installation/upgrade_150.html
+++ b/user_guide/installation/upgrade_150.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrade_152.html b/user_guide/installation/upgrade_152.html
index d0a19ba..370e3b8 100644
--- a/user_guide/installation/upgrade_152.html
+++ b/user_guide/installation/upgrade_152.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrade_153.html b/user_guide/installation/upgrade_153.html
index 5671b48..33d3837 100644
--- a/user_guide/installation/upgrade_153.html
+++ b/user_guide/installation/upgrade_153.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrade_154.html b/user_guide/installation/upgrade_154.html
index 07dfa5d..6e8316c 100644
--- a/user_guide/installation/upgrade_154.html
+++ b/user_guide/installation/upgrade_154.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Upgrading from 1.5.3 to 1.5.4</title>
diff --git a/user_guide/installation/upgrade_160.html b/user_guide/installation/upgrade_160.html
index dffbb76..231404d 100644
--- a/user_guide/installation/upgrade_160.html
+++ b/user_guide/installation/upgrade_160.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Upgrading from 1.5.3 to 1.5.4</title>
diff --git a/user_guide/installation/upgrade_b11.html b/user_guide/installation/upgrade_b11.html
index 09e93c0..1f47418 100644
--- a/user_guide/installation/upgrade_b11.html
+++ b/user_guide/installation/upgrade_b11.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/installation/upgrading.html b/user_guide/installation/upgrading.html
index fccebe0..c40da5a 100644
--- a/user_guide/installation/upgrading.html
+++ b/user_guide/installation/upgrading.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Upgrading From a Previous Version</title>
diff --git a/user_guide/libraries/benchmark.html b/user_guide/libraries/benchmark.html
index 1a91abf..9fcd645 100644
--- a/user_guide/libraries/benchmark.html
+++ b/user_guide/libraries/benchmark.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Benchmarking Class</title>
diff --git a/user_guide/libraries/calendar.html b/user_guide/libraries/calendar.html
index 5e4e30c..2e75a7e 100644
--- a/user_guide/libraries/calendar.html
+++ b/user_guide/libraries/calendar.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Calendaring Class</title>
diff --git a/user_guide/libraries/config.html b/user_guide/libraries/config.html
index bf653fe..93b0857 100644
--- a/user_guide/libraries/config.html
+++ b/user_guide/libraries/config.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Config Class</title>
diff --git a/user_guide/libraries/email.html b/user_guide/libraries/email.html
index 01085d5..6da687b 100644
--- a/user_guide/libraries/email.html
+++ b/user_guide/libraries/email.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Email Class</title>
diff --git a/user_guide/libraries/encryption.html b/user_guide/libraries/encryption.html
index c4499a8..1890c2e 100644
--- a/user_guide/libraries/encryption.html
+++ b/user_guide/libraries/encryption.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Encryption Class</title>
diff --git a/user_guide/libraries/file_uploading.html b/user_guide/libraries/file_uploading.html
index 46f6120..64a9303 100644
--- a/user_guide/libraries/file_uploading.html
+++ b/user_guide/libraries/file_uploading.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : File Uploading Class</title>
diff --git a/user_guide/libraries/ftp.html b/user_guide/libraries/ftp.html
index 87309f8..8f3c10a 100644
--- a/user_guide/libraries/ftp.html
+++ b/user_guide/libraries/ftp.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : FTP Class</title>
diff --git a/user_guide/libraries/image_lib.html b/user_guide/libraries/image_lib.html
index 1cca5bc..9cb31a5 100644
--- a/user_guide/libraries/image_lib.html
+++ b/user_guide/libraries/image_lib.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Image Manipulation Class</title>
diff --git a/user_guide/libraries/input.html b/user_guide/libraries/input.html
index e1c5fcb..0cd81e3 100644
--- a/user_guide/libraries/input.html
+++ b/user_guide/libraries/input.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Input Class</title>
diff --git a/user_guide/libraries/language.html b/user_guide/libraries/language.html
index 38fd4ae..72fec89 100644
--- a/user_guide/libraries/language.html
+++ b/user_guide/libraries/language.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Language Class</title>
diff --git a/user_guide/libraries/loader.html b/user_guide/libraries/loader.html
index 56ccc21..ad120f5 100644
--- a/user_guide/libraries/loader.html
+++ b/user_guide/libraries/loader.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Loader Class</title>
diff --git a/user_guide/libraries/output.html b/user_guide/libraries/output.html
index 827cc8b..1905f32 100644
--- a/user_guide/libraries/output.html
+++ b/user_guide/libraries/output.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Output Class</title>
diff --git a/user_guide/libraries/pagination.html b/user_guide/libraries/pagination.html
index f8389f9..e8696f6 100644
--- a/user_guide/libraries/pagination.html
+++ b/user_guide/libraries/pagination.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Pagination Class</title>
diff --git a/user_guide/libraries/parser.html b/user_guide/libraries/parser.html
index 8bf4afd..0809ea1 100644
--- a/user_guide/libraries/parser.html
+++ b/user_guide/libraries/parser.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Template Parser Class</title>
diff --git a/user_guide/libraries/sessions.html b/user_guide/libraries/sessions.html
index 86d6e16..7d6c693 100644
--- a/user_guide/libraries/sessions.html
+++ b/user_guide/libraries/sessions.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide</title>
diff --git a/user_guide/libraries/table.html b/user_guide/libraries/table.html
index 59930d4..0c15a07 100644
--- a/user_guide/libraries/table.html
+++ b/user_guide/libraries/table.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : HTML Table Class</title>
diff --git a/user_guide/libraries/trackback.html b/user_guide/libraries/trackback.html
index d816fab..b095606 100644
--- a/user_guide/libraries/trackback.html
+++ b/user_guide/libraries/trackback.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Trackback Class</title>
diff --git a/user_guide/libraries/unit_testing.html b/user_guide/libraries/unit_testing.html
index 0143c9c..70567fc 100644
--- a/user_guide/libraries/unit_testing.html
+++ b/user_guide/libraries/unit_testing.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Unit Testing Class</title>
diff --git a/user_guide/libraries/uri.html b/user_guide/libraries/uri.html
index 180e56c..6c424cb 100644
--- a/user_guide/libraries/uri.html
+++ b/user_guide/libraries/uri.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : URI Class</title>
diff --git a/user_guide/libraries/user_agent.html b/user_guide/libraries/user_agent.html
index 1d11fbd..59304f6 100644
--- a/user_guide/libraries/user_agent.html
+++ b/user_guide/libraries/user_agent.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : User Agent Class</title>
diff --git a/user_guide/libraries/validation.html b/user_guide/libraries/validation.html
index 377503b..af5631c 100644
--- a/user_guide/libraries/validation.html
+++ b/user_guide/libraries/validation.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Form Validation</title>
diff --git a/user_guide/libraries/xmlrpc.html b/user_guide/libraries/xmlrpc.html
index a44f8bd..49678a6 100644
--- a/user_guide/libraries/xmlrpc.html
+++ b/user_guide/libraries/xmlrpc.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : XML-RPC and XML-RPC Server Classes</title>
diff --git a/user_guide/libraries/zip.html b/user_guide/libraries/zip.html
index 23e7587..8361c92 100644
--- a/user_guide/libraries/zip.html
+++ b/user_guide/libraries/zip.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Zip Encoding Class</title>
diff --git a/user_guide/license.html b/user_guide/license.html
index b823025..5962967 100644
--- a/user_guide/license.html
+++ b/user_guide/license.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : CodeIgniter License Agreement</title>
diff --git a/user_guide/overview/appflow.html b/user_guide/overview/appflow.html
index 2a7e562..74e6f70 100644
--- a/user_guide/overview/appflow.html
+++ b/user_guide/overview/appflow.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Application Flow Chart</title>
diff --git a/user_guide/overview/at_a_glance.html b/user_guide/overview/at_a_glance.html
index 665d0a5..2820810 100644
--- a/user_guide/overview/at_a_glance.html
+++ b/user_guide/overview/at_a_glance.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : CodeIgniter at a Glance</title>
diff --git a/user_guide/overview/features.html b/user_guide/overview/features.html
index 4d380b7..139dd8c8 100644
--- a/user_guide/overview/features.html
+++ b/user_guide/overview/features.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : CodeIgniter Features</title>
diff --git a/user_guide/overview/goals.html b/user_guide/overview/goals.html
index 61d156b..bcbd179 100644
--- a/user_guide/overview/goals.html
+++ b/user_guide/overview/goals.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Design and Architectural Goals</title>
diff --git a/user_guide/overview/index.html b/user_guide/overview/index.html
index 7a05862..2f3df3c 100644
--- a/user_guide/overview/index.html
+++ b/user_guide/overview/index.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : CodeIgniter Overview</title>
diff --git a/user_guide/overview/mvc.html b/user_guide/overview/mvc.html
index 603e58a..03c94fe 100644
--- a/user_guide/overview/mvc.html
+++ b/user_guide/overview/mvc.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Model-View-Controller</title>
diff --git a/user_guide/toc.html b/user_guide/toc.html
index 465d8f4..b729b52 100644
--- a/user_guide/toc.html
+++ b/user_guide/toc.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 
 <title>CodeIgniter User Guide : Table of Contents</title>
